package com.qidianit.mes.pro.service.impl;

import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.qidianit.mes.pojo.CodeAutoInfo;
import com.qidianit.mes.pojo.Result;
import com.qidianit.mes.pojo.pro.Process;
import com.qidianit.mes.pro.mapper.CodeAutoInfoMapper;
import com.qidianit.mes.pro.mapper.ProcessMapper;
import com.qidianit.mes.pro.service.ProcessService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Transactional;

import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.util.Date;
import java.util.List;

/**
 * 工序服务实现类
 */
@Service
public class ProcessServiceImpl implements ProcessService {
    @Autowired
    private ProcessMapper processMapper;
    @Autowired
    private CodeAutoInfoMapper codeAutoInfoMapper;

    @Value("${process_code_type}")
    private String processCodeType;

    @Override
    @Transactional(isolation = Isolation.REPEATABLE_READ)
    public synchronized Result<String> autoCode() {
        CodeAutoInfo codeAutoInfo = codeAutoInfoMapper.selectByType(processCodeType);
        // 放入前缀
        StringBuilder sb = new StringBuilder(codeAutoInfo.getPre());
        // 日期
        sb.append(new SimpleDateFormat("YYMMdd").format(new Date()));
        // 序列号
        Integer sequence = codeAutoInfo.getSequence(); //
        // 在序列号前面补0
        for (int i = 0; i < 4 - sequence.toString().length(); i++) {
            sb.append("0");
        }
        sb.append(sequence.toString());
        // 将序列号+1，再保存回去
        codeAutoInfo.setSequence(codeAutoInfo.getSequence() + 1);
        codeAutoInfoMapper.update(codeAutoInfo);
        return Result.success(sb.toString());
    }

    /**
     * 分页查询工序列表（多条件筛选）
     */
    @Override
    public Result<PageInfo<Process>> selectList(Process process, int pageNum, int pageSize) {
        try {
// 1. 开启分页（PageHelper 插件自动拦截 SQL 实现分页）
            PageHelper.startPage(pageNum, pageSize);
// 2. 执行多条件查询（Mapper 层已处理逻辑删除过滤）
            List<Process> processList = processMapper.selectList(process);
// 3. 封装分页信息（包含总条数、总页数等）
            PageInfo<Process> pageInfo = new PageInfo<>(processList);
            return Result.success(pageInfo);
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error("工序列表查询失败：" + e.getMessage());
        }
    }

    /**
     * 根据工序编码精确查询（唯一校验基础）
     */
    @Override
    public Result<Process> selectByCode(String processCode) {
        try {
// 1. 参数非空校验
            if (processCode == null || processCode.trim().isEmpty()) {
                return Result.error("工序编码不能为空");
            }
// 2. 执行查询（自动过滤已删除数据）
            Process process = processMapper.selectByCode(processCode);
            if (process != null) {
                return Result.success(process);
            } else {
                return Result.error("未查询到编码为【" + processCode + "】的工序");
            }
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error("工序编码查询失败：" + e.getMessage());
        }
    }

    /**
     * 新增工序（含编码唯一校验、默认值设置）
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public Result saveProcess(Process process) {
        try {
            // 1. 核心参数校验（必填字段）
            if (process.getProcessCode() == null || process.getProcessCode().trim().isEmpty()) {
                return Result.error("工序编码不能为空");
            }
            if (process.getProcessName() == null || process.getProcessName().trim().isEmpty()) {
                return Result.error("工序名称不能为空");
            }
            // 2. 工序编码唯一性校验（避免重复）
            Process existProcess = processMapper.selectByCode(process.getProcessCode());
            if (existProcess != null) {
                return Result.error("工序编码【" + process.getProcessCode() + "】已存在，请更换编码");
            }
            // 3. 设置默认值（简化前端传参，保证数据一致性）
            if (process.getIsActive() == null) {
                process.setIsActive(1); // 默认启用（1 = 启用，0 = 禁用）
            }
            if (process.getIsDeleted() == null) {
                process.setIsDeleted(0); // 默认未删除（0 = 未删除，1 = 已删除）
            }
            process.setCreateTime(LocalDateTime.now()); // 自动填充创建时间
            process.setUpdateTime(LocalDateTime.now()); // 初始更新时间与创建时间一致
// 4. 执行新增操作
            int insertRows = processMapper.saveProcess(process);
            if (insertRows > 0) {
                return Result.success("工序【" + process.getProcessName() + "】新增成功");
            } else {
                return Result.error("工序新增失败，无数据插入");
            }
        } catch (Exception e) {
            e.printStackTrace();
// 事务回滚（@Transactional 注解生效）
            throw new RuntimeException("工序新增异常：" + e.getMessage());
        }
    }

    /**
     * 根据 ID 编辑工序（含编码唯一校验、更新时间填充）
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public Result updateById(Process process) {
        try {
            // 1. 主键 ID 校验（必传）
            if (process.getId() == null) {
                return Result.error("工序 ID 不能为空，无法更新");
            }
            // 2. 工序编码唯一性校验（排除当前更新的工序本身）
            Process processTemp = processMapper.selectByCode(process.getProcessCode());
            if(processTemp != null && !processTemp.getId().equals(process.getId())){
                // 重复了
                return Result.error("工序编码【" + process.getProcessCode() + "】已存在，请更换编码");
            }
            // 3. 填充更新时间（强制更新，避免手动传参错误）
            process.setUpdateTime(LocalDateTime.now());
            // 4. 执行更新操作（Mapper 层已过滤已删除数据）
            int updateRows = processMapper.updateById(process);
            if (updateRows > 0) {
                return Result.success("工序 ID【" + process.getId() + "】更新成功");
            } else {
                return Result.error("工序更新失败，未找到该工序或数据无变更");
            }
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException("工序更新异常：" + e.getMessage());
        }
    }

    /**
     * 根据 ID 逻辑删除工序（修改 is_deleted 为 1）
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public Result deleteById(Long id) {
        try {
// 1. 主键 ID 校验
            if (id == null) {
                return Result.error("工序 ID 不能为空，无法删除");
            }
// 2. 执行逻辑删除（自动更新 update_time）
            int deleteRows = processMapper.deleteById(id);
            if (deleteRows > 0) {
                return Result.success("工序 ID【" + id + "】删除成功");
            } else {
                return Result.error("工序删除失败，未找到该工序或已删除");
            }
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException("工序删除异常：" + e.getMessage());
        }
    }

    /**
     * 批量逻辑删除工序
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public Result batchDelete(Long[] ids) {
        try {
// 1. 数组参数校验（至少选择一条数据）
            if (ids == null || ids.length == 0) {
                return Result.error("请选择需要删除的工序");
            }
// 2. 执行批量删除
            int deleteRows = processMapper.batchDelete(ids);
            if (deleteRows > 0) {
                return Result.success("成功删除【" + deleteRows + "】条工序数据");
            } else {
                return Result.error("批量删除失败，未找到选中的工序或已删除");
            }
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException("工序批量删除异常：" + e.getMessage());
        }
    }
}